package com.aspire.aimini.service.impl;

import com.aspire.aimini.model.entity.AiConfig;
import com.aspire.aimini.repository.AiConfigRepository;
import com.aspire.aimini.service.AiConfigService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import cn.dev33.satoken.stp.StpUtil;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * AI配置服务实现类
 *
 * @author wangguiyou
 * @date 2024-12-19
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class AiConfigServiceImpl implements AiConfigService {

    private final AiConfigRepository aiConfigRepository;

    /**
     * 创建AI配置
     *
     * @param serviceType  服务类型
     * @param provider     提供商
     * @param modelName    模型名称
     * @param apiKey       API密钥
     * @param apiUrl       API地址
     * @param configParams 配置参数
     * @param rateLimit    调用频率限制
     * @param dailyQuota   每日配额
     * @param isDefault    是否默认配置
     * @param userId       用户ID
     * @return 创建的配置
     */
        @Override
    @Transactional(rollbackFor = Exception.class)
    public AiConfig createConfig(String serviceType, String provider, String modelName, String apiKey,
            String apiUrl, String configParams, Integer rateLimit, Integer dailyQuota,
            Boolean isDefault) {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("创建AI配置: provider={}, model={}, userId={}", provider, modelName, userId);

        AiConfig config = new AiConfig();
        config.setServiceType(serviceType);
        config.setProvider(provider);
        config.setModel(modelName);
        config.setApiKey(apiKey);
        config.setApiUrl(apiUrl);
        config.setConfigParams(configParams);
        config.setRateLimit(rateLimit);
        config.setDailyLimit(dailyQuota);
        config.setIsDefault(isDefault);
        config.setUserId(userId);
        
        config.setCreatedAt(LocalDateTime.now());
        config.setUpdatedAt(LocalDateTime.now());
        config.setTodayUsage(0);
        config.setTotalUsage(0);
        config.setIsEnabled(true);
        config.setIsDeleted(false);

        aiConfigRepository.insert(config);
        return config;
    }

    /**
     * 分页查询AI配置列表
     *
     * @param userId      用户ID
     * @param serviceType 服务类型
     * @param provider    提供商
     * @param status      状态
     * @param page        页码
     * @param size        每页大小
     * @return 分页结果
     */
        @Override
    public IPage<AiConfig> getConfigPage(String serviceType, String provider, Integer status, Integer page,
            Integer size) {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("分页查询AI配置: page={}, size={}, userId={}, serviceType={}, provider={}, status={}",
                page, size, userId, serviceType, provider, status);

        Page<AiConfig> pageParam = new Page<>(page, size);
        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();

        wrapper.eq(AiConfig::getIsDeleted, false)
                .eq(userId != null, AiConfig::getUserId, userId)
                .eq(StringUtils.hasText(serviceType), AiConfig::getServiceType, serviceType)
                .eq(StringUtils.hasText(provider), AiConfig::getProvider, provider)
                .eq(status != null, AiConfig::getIsEnabled, status == 1)
                .orderByDesc(AiConfig::getIsDefault)
                .orderByDesc(AiConfig::getCreatedAt);

        return aiConfigRepository.selectPage(pageParam, wrapper);
    }

    /**
     * 根据ID获取AI配置
     *
     * @param id     配置ID
     * @param userId 用户ID
     * @return AI配置信息
     */
        @Override
    public AiConfig getConfigById(Long id) {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("根据ID获取AI配置: id={}, userId={}", id, userId);

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AiConfig::getId, id)
                .eq(userId != null, AiConfig::getUserId, userId)
                .eq(AiConfig::getIsDeleted, false);

        AiConfig aiConfig = aiConfigRepository.selectOne(wrapper);
        if (aiConfig == null) {
            throw new RuntimeException("AI配置不存在: " + id);
        }
        return aiConfig;
    }

    /**
     * 根据用户ID和服务类型获取配置
     *
     * @param userId      用户ID
     * @param serviceType 服务类型
     * @return AI配置列表
     */
        @Override
    public List<AiConfig> getConfigsByUserIdAndServiceType(String serviceType) {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("根据用户ID和服务类型获取配置: userId={}, serviceType={}", userId, serviceType);

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AiConfig::getUserId, userId)
                .eq(AiConfig::getServiceType, serviceType)
                .eq(AiConfig::getIsDeleted, false)
                .eq(AiConfig::getIsEnabled, true)
                .orderByDesc(AiConfig::getIsDefault)
                .orderByDesc(AiConfig::getCreatedAt);

        return aiConfigRepository.selectList(wrapper);
    }

    /**
     * 获取用户的默认配置
     *
     * @param userId      用户ID
     * @param serviceType 服务类型
     * @return 默认配置
     */
        @Override
    public AiConfig getDefaultConfig(String serviceType) {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("获取默认配置: userId={}, serviceType={}", userId, serviceType);

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AiConfig::getUserId, userId)
                .eq(AiConfig::getServiceType, serviceType)
                .eq(AiConfig::getIsDefault, true)
                .eq(AiConfig::getIsDeleted, false)
                .eq(AiConfig::getIsEnabled, true)
                .orderByDesc(AiConfig::getCreatedAt)
                .last("LIMIT 1");

        return aiConfigRepository.selectOne(wrapper);
    }

    /**
     * 获取系统默认配置
     *
     * @param serviceType 服务类型
     * @return 系统默认AI配置
     */
    @Override
    public AiConfig getSystemDefaultConfig(String serviceType) {
        log.info("获取系统默认配置: serviceType={}", serviceType);

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.isNull(AiConfig::getUserId)
                .eq(AiConfig::getServiceType, serviceType)
                .eq(AiConfig::getIsDefault, true)
                .eq(AiConfig::getIsDeleted, false)
                .eq(AiConfig::getIsEnabled, true)
                .orderByDesc(AiConfig::getCreatedAt)
                .last("LIMIT 1");

        return aiConfigRepository.selectOne(wrapper);
    }

    /**
     * 更新AI配置
     *
     * @param id           配置ID
     * @param serviceType  服务类型
     * @param provider     提供商
     * @param modelName    模型名称
     * @param apiKey       API密钥
     * @param apiUrl       API地址
     * @param configParams 配置参数
     * @param rateLimit    调用频率限制
     * @param dailyQuota   每日配额
     * @param isDefault    是否默认配置
     * @param status       状态
     * @param userId       用户ID
     * @return 更新后的配置
     */
        @Override
    @Transactional(rollbackFor = Exception.class)
    public AiConfig updateConfig(Long id, String serviceType, String provider, String modelName, String apiKey,
            String apiUrl, String configParams, Integer rateLimit, Integer dailyQuota,
            Boolean isDefault, Integer status) {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("更新AI配置: id={}, userId={}", id, userId);

        getConfigById(id, userId); // 检查配置是否存在

        AiConfig config = new AiConfig();
        config.setId(id);
        config.setServiceType(serviceType);
        config.setProvider(provider);
        config.setModel(modelName);
        config.setApiKey(apiKey);
        config.setApiUrl(apiUrl);
        config.setConfigParams(configParams);
        config.setRateLimit(rateLimit);
        config.setDailyLimit(dailyQuota);
        config.setIsDefault(isDefault);
        config.setIsEnabled(status == 1);
        config.setUserId(userId);
        config.setUpdatedAt(LocalDateTime.now());

        aiConfigRepository.updateById(config);

        return getConfigById(id, userId);
    }

    /**
     * 删除AI配置
     *
     * @param id     配置ID
     * @param userId 用户ID
     */
        @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteConfig(Long id) {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("删除AI配置: id={}, userId={}", id, userId);

        getConfigById(id, userId); // 检查配置是否存在

        LambdaUpdateWrapper<AiConfig> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(AiConfig::getId, id)
                .set(AiConfig::getIsDeleted, true)
                .set(AiConfig::getUpdatedAt, LocalDateTime.now());

        aiConfigRepository.update(null, wrapper);
    }

    /**
     * 批量删除AI配置
     *
     * @param ids    配置ID列表
     * @param userId 用户ID
     */
        @Override
    @Transactional(rollbackFor = Exception.class)
    public void batchDeleteConfigs(List<Long> ids) {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("批量删除AI配置: ids={}, userId={}", ids, userId);

        if (ids == null || ids.isEmpty()) {
            return;
        }

        LambdaUpdateWrapper<AiConfig> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(AiConfig::getId, ids)
                .eq(userId != null, AiConfig::getUserId, userId)
                .set(AiConfig::getIsDeleted, true)
                .set(AiConfig::getUpdatedAt, LocalDateTime.now());

        aiConfigRepository.update(null, wrapper);
    }

    /**
     * 设置默认配置
     *
     * @param configId 配置ID
     * @param userId   用户ID
     */
        @Override
    @Transactional(rollbackFor = Exception.class)
    public void setDefaultConfig(Long configId) {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("设置默认配置: configId={}, userId={}", configId, userId);

        AiConfig config = getConfigById(configId, userId);

        // 先清除同用户同服务类型的其他默认配置
        LambdaUpdateWrapper<AiConfig> clearWrapper = new LambdaUpdateWrapper<>();
        clearWrapper.eq(AiConfig::getUserId, config.getUserId())
                .eq(AiConfig::getServiceType, config.getServiceType())
                .eq(AiConfig::getIsDeleted, false)
                .set(AiConfig::getIsDefault, false)
                .set(AiConfig::getUpdatedAt, LocalDateTime.now());

        aiConfigRepository.update(null, clearWrapper);

        // 设置当前配置为默认
        LambdaUpdateWrapper<AiConfig> setWrapper = new LambdaUpdateWrapper<>();
        setWrapper.eq(AiConfig::getId, configId)
                .set(AiConfig::getIsDefault, true)
                .set(AiConfig::getUpdatedAt, LocalDateTime.now());

        aiConfigRepository.update(null, setWrapper);
    }

    /**
     * 测试配置连接
     *
     * @param id     配置ID
     * @param userId 用户ID
     * @return 测试结果
     */
        @Override
    public Map<String, Object> testConfig(Long id) {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("测试配置连接: id={}, userId={}", id, userId);

        AiConfig config = getConfigById(id, userId);
        Map<String, Object> result = new HashMap<>();

        try {
            // TODO: 根据不同的提供商和服务类型实现具体的连接测试逻辑
            boolean success = mockConnectionTest(config);
            result.put("success", success);
            result.put("message", success ? "连接成功" : "连接失败");
            return result;
        } catch (Exception e) {
            log.error("测试配置连接失败: id={}, userId={}, error={}", id, userId, e.getMessage(), e);
            result.put("success", false);
            result.put("message", "连接失败: " + e.getMessage());
            return result;
        }
    }

    /**
     * 增加今日使用量
     *
     * @param id     配置ID
     * @param amount 使用量
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void incrementTodayUsed(Long id, Integer amount) {
        log.info("增加今日使用量: id={}, amount={}", id, amount);

        LambdaUpdateWrapper<AiConfig> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(AiConfig::getId, id)
                .setSql("today_usage = today_usage + " + amount)
                .set(AiConfig::getUpdatedAt, LocalDateTime.now());

        aiConfigRepository.update(null, wrapper);
    }

    /**
     * 重置今日使用量
     *
     * @param id 配置ID
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void resetTodayUsed(Long id) {
        log.info("重置今日使用量: id={}", id);

        LambdaUpdateWrapper<AiConfig> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(AiConfig::getId, id)
                .eq(AiConfig::getIsDeleted, false)
                .set(AiConfig::getTodayUsage, 0)
                .set(AiConfig::getUpdatedAt, LocalDateTime.now());

        aiConfigRepository.update(null, wrapper);
    }

    /**
     * 批量重置今日使用量
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void batchResetTodayUsed() {
        log.info("批量重置今日使用量");

        LambdaUpdateWrapper<AiConfig> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(AiConfig::getIsDeleted, false)
                .set(AiConfig::getTodayUsage, 0)
                .set(AiConfig::getUpdatedAt, LocalDateTime.now());

        aiConfigRepository.update(null, wrapper);
    }

    /**
     * 检查配置是否可用
     *
     * @param id 配置ID
     * @return 是否可用
     */
    @Override
    public boolean isConfigAvailable(Long id) {
        log.info("检查配置是否可用: {}", id);

        try {
            AiConfig config = getAiConfigById(id);

            // 检查配置是否启用
            if (!config.getIsEnabled()) {
                return false;
            }

            // 检查是否超出每日限制
            if (config.getDailyLimit() != null && config.getTodayUsage() >= config.getDailyLimit()) {
                return false;
            }

            // 检查是否超出总限制
            if (config.getTotalLimit() != null && config.getTotalUsage() >= config.getTotalLimit()) {
                return false;
            }

            return true;
        } catch (Exception e) {
            log.error("检查配置可用性失败: id={}, error={}", id, e.getMessage());
            return false;
        }
    }

    /**
     * 根据提供商获取配置列表
     *
     * @param provider 提供商
     * @param status   状态
     * @return 配置列表
     */
    @Override
    public List<AiConfig> getConfigsByProvider(String provider, Integer status) {
        log.info("根据提供商获取配置列表: provider={}, status={}", provider, status);

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AiConfig::getProvider, provider)
                .eq(AiConfig::getIsDeleted, false)
                .eq(status != null, AiConfig::getIsEnabled, status == 1)
                .orderByDesc(AiConfig::getCreatedAt);

        return aiConfigRepository.selectList(wrapper);
    }

    /**
     * 统计用户配置数量
     *
     * @param userId 用户ID
     * @return 配置数量
     */
        @Override
    public Long countUserConfigs() {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("统计用户配置数量: userId={}", userId);

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(userId != null, AiConfig::getUserId, userId)
                .eq(AiConfig::getIsDeleted, false);

        return aiConfigRepository.selectCount(wrapper);
    }

    /**
     * 按服务类型统计配置数量
     *
     * @param userId 用户ID
     * @return 统计结果
     */
        @Override
    public List<Map<String, Object>> countByServiceType() {
        Long userId = StpUtil.getLoginIdAsLong();
        log.info("按服务类型统计配置数量: userId={}", userId);

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(AiConfig::getServiceType)
                .eq(userId != null, AiConfig::getUserId, userId)
                .eq(AiConfig::getIsDeleted, false)
                .isNotNull(AiConfig::getServiceType)
                .ne(AiConfig::getServiceType, "");

        List<AiConfig> configs = aiConfigRepository.selectList(wrapper);

        Map<String, Long> countMap = configs.stream()
                .collect(Collectors.groupingBy(
                        config -> StringUtils.hasText(config.getServiceType()) ? config.getServiceType() : "未分类",
                        Collectors.counting()));
                        
        return countMap.entrySet().stream()
                .map(entry -> {
                    Map<String, Object> item = new HashMap<>();
                    item.put("serviceType", entry.getKey());
                    item.put("count", entry.getValue());
                    return item;
                })
                .collect(Collectors.toList());
    }

    /**
     * 按提供商统计配置数量
     *
     * @return 统计结果
     */
    @Override
    public List<Map<String, Object>> countByProvider() {
        log.info("按提供商统计配置数量");

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(AiConfig::getProvider)
                .eq(AiConfig::getIsDeleted, false)
                .isNotNull(AiConfig::getProvider)
                .ne(AiConfig::getProvider, "");

        List<AiConfig> configs = aiConfigRepository.selectList(wrapper);

        Map<String, Long> countMap = configs.stream()
                .collect(Collectors.groupingBy(
                        config -> StringUtils.hasText(config.getProvider()) ? config.getProvider() : "未知提供商",
                        Collectors.counting()));
                        
        return countMap.entrySet().stream()
                .map(entry -> {
                    Map<String, Object> item = new HashMap<>();
                    item.put("provider", entry.getKey());
                    item.put("count", entry.getValue());
                    return item;
                })
                .collect(Collectors.toList());
    }

    /**
     * 获取即将达到配额限制的配置
     *
     * @param threshold 阈值(百分比)
     * @return 配置列表
     */
    @Override
    public List<AiConfig> getNearQuotaLimitConfigs(Double threshold) {
        log.info("获取即将达到配额限制的配置: threshold={}", threshold);

        double thresholdValue = threshold != null ? threshold : 0.8; // 默认80%

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AiConfig::getIsDeleted, false)
                .eq(AiConfig::getIsEnabled, true)
                .isNotNull(AiConfig::getDailyLimit)
                .gt(AiConfig::getDailyLimit, 0);

        List<AiConfig> configs = aiConfigRepository.selectList(wrapper);

        return configs.stream()
                .filter(config -> {
                    double usageRatio = (double) config.getTodayUsage() / config.getDailyLimit();
                    return usageRatio >= thresholdValue && usageRatio < 1.0; // 接近但未超出
                })
                .collect(Collectors.toList());
    }
    
    /**
     * 获取已超出配额的配置
     *
     * @return 配置列表
     */
    @Override
    public List<AiConfig> getOverQuotaConfigs() {
        log.info("获取已超出配额的配置");

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AiConfig::getIsDeleted, false)
                .eq(AiConfig::getIsEnabled, true)
                .isNotNull(AiConfig::getDailyLimit)
                .gt(AiConfig::getDailyLimit, 0);

        List<AiConfig> configs = aiConfigRepository.selectList(wrapper);

        return configs.stream()
                .filter(config -> {
                    double usageRatio = (double) config.getTodayUsage() / config.getDailyLimit();
                    return usageRatio >= 1.0; // 已超出配额
                })
                .collect(Collectors.toList());
    }

    /**
     * 获取已超出配额的配置
     *
     * @return 配置列表
     */
    @Override
    public List<AiConfig> getConfigsOverQuotaLimit() {
        log.info("获取已超出配额的配置");

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AiConfig::getIsDeleted, false)
                .eq(AiConfig::getIsEnabled, true)
                .isNotNull(AiConfig::getDailyLimit)
                .gt(AiConfig::getDailyLimit, 0)
                .apply("today_usage >= daily_limit");

        return aiConfigRepository.selectList(wrapper);
    }

    /**
     * 获取用户配置统计信息
     *
     * @param userId 用户ID
     * @return 统计信息
     */
    @Override
    public Map<String, Object> getUserConfigStats(Long userId) {
        log.info("获取用户配置统计信息: userId={}", userId);

        Map<String, Object> statistics = new HashMap<>();

        // 总配置数
        Long totalCount = countUserConfigs(userId);
        statistics.put("totalCount", totalCount);

        // 启用配置数
        LambdaQueryWrapper<AiConfig> enabledWrapper = new LambdaQueryWrapper<>();
        enabledWrapper.eq(AiConfig::getUserId, userId)
                .eq(AiConfig::getIsDeleted, false)
                .eq(AiConfig::getIsEnabled, true);
        long enabledCount = aiConfigRepository.selectCount(enabledWrapper);
        statistics.put("enabledCount", enabledCount);

        // 默认配置数
        LambdaQueryWrapper<AiConfig> defaultWrapper = new LambdaQueryWrapper<>();
        defaultWrapper.eq(AiConfig::getUserId, userId)
                .eq(AiConfig::getIsDeleted, false)
                .eq(AiConfig::getIsDefault, true);
        long defaultCount = aiConfigRepository.selectCount(defaultWrapper);
        statistics.put("defaultCount", defaultCount);

        // 按服务类型统计
        statistics.put("countByServiceType", getConfigCountByServiceType(userId));

        // 按提供商统计
        statistics.put("countByProvider", getConfigCountByProvider(userId));

        return statistics;
    }

    /**
     * 复制配置
     *
     * @param id     配置ID
     * @param userId 目标用户ID
     * @return 复制的配置
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AiConfig copyConfig(Long id, Long userId) {
        log.info("复制配置: id={}, userId={}", id, userId);

        AiConfig original = getConfigById(id, userId);

        AiConfig copy = new AiConfig();
        copy.setUserId(userId);
        copy.setServiceType(original.getServiceType());
        copy.setProvider(original.getProvider());
        copy.setModel(original.getModel());
        copy.setApiKey(original.getApiKey());
        copy.setApiUrl(original.getApiUrl());
        copy.setDailyLimit(original.getDailyLimit());
        copy.setTotalLimit(original.getTotalLimit());
        copy.setIsDefault(false); // 复制的配置默认不是默认配置
        copy.setIsEnabled(true);
        copy.setIsDeleted(false);
        copy.setTodayUsage(0);
        copy.setTotalUsage(0);
        copy.setCreatedAt(LocalDateTime.now());
        copy.setUpdatedAt(LocalDateTime.now());

        aiConfigRepository.insert(copy);
        return copy;
    }

    /**
     * 启用配置
     *
     * @param id 配置ID
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void enableConfig(Long id, Long userId) {
        log.info("启用配置: id={}, userId={}", id, userId);

        getConfigById(id, userId); // 检查配置是否存在

        LambdaUpdateWrapper<AiConfig> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(AiConfig::getId, id)
                .eq(AiConfig::getUserId, userId)
                .set(AiConfig::getIsEnabled, true)
                .set(AiConfig::getUpdatedAt, LocalDateTime.now());

        aiConfigRepository.update(null, wrapper);
    }

    /**
     * 禁用配置
     *
     * @param id 配置ID
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void disableConfig(Long id, Long userId) {
        log.info("禁用配置: id={}, userId={}", id, userId);

        getConfigById(id, userId); // 检查配置是否存在

        LambdaUpdateWrapper<AiConfig> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(AiConfig::getId, id)
                .eq(AiConfig::getUserId, userId)
                .set(AiConfig::getIsEnabled, false)
                .set(AiConfig::getUpdatedAt, LocalDateTime.now());

        aiConfigRepository.update(null, wrapper);
    }

    /**
     * 批量更新配置状态
     *
     * @param ids       配置ID列表
     * @param isEnabled 是否启用
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void batchUpdateStatus(List<Long> ids, Integer status, Long userId) {
        log.info("批量更新配置状态: ids={}, status={}, userId={}", ids, status, userId);

        if (ids == null || ids.isEmpty()) {
            return;
        }

        boolean isEnabled = status == 1;

        LambdaUpdateWrapper<AiConfig> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(AiConfig::getId, ids)
                .eq(userId != null, AiConfig::getUserId, userId)
                .set(AiConfig::getIsEnabled, isEnabled)
                .set(AiConfig::getUpdatedAt, LocalDateTime.now());

        aiConfigRepository.update(null, wrapper);
    }

    /**
     * 导入配置
     *
     * @param configData 配置数据
     * @param userId     用户ID
     * @return 导入的配置列表
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public List<AiConfig> importConfigs(String configData, Long userId) {
        log.info("导入配置: userId={}", userId);

        try {
            // 解析JSON
            ObjectMapper objectMapper = new ObjectMapper();
            List<Map<String, Object>> configList = objectMapper.readValue(configData, 
                    objectMapper.getTypeFactory().constructCollectionType(List.class, Map.class));

            // 导入配置
            List<AiConfig> importedConfigs = new ArrayList<>();
            LocalDateTime now = LocalDateTime.now();
            
            for (Map<String, Object> configMap : configList) {
                AiConfig config = new AiConfig();
                // 设置配置属性
                config.setServiceType((String) configMap.get("serviceType"));
                config.setProvider((String) configMap.get("provider"));
                config.setModel((String) configMap.get("model"));
                config.setApiKey((String) configMap.get("apiKey"));
                config.setApiUrl((String) configMap.get("apiUrl"));
                config.setDailyLimit((Integer) configMap.get("dailyLimit"));
                config.setTotalLimit((Integer) configMap.get("totalLimit"));
                
                config.setUserId(userId);
                config.setIsDefault(false);
                config.setIsEnabled(true);
                config.setIsDeleted(false);
                config.setTodayUsage(0);
                config.setTotalUsage(0);
                config.setCreatedAt(now);
                config.setUpdatedAt(now);

                aiConfigRepository.insert(config);
                importedConfigs.add(config);
            }

            return importedConfigs;
        } catch (JsonProcessingException e) {
            log.error("导入配置失败", e);
            throw new RuntimeException("导入配置失败: " + e.getMessage());
        }
    }

    /**
     * 导出配置
     *
     * @param ids    配置ID列表
     * @param userId 用户ID
     * @return 配置JSON字符串
     */
    @Override
    public String exportConfigs(List<Long> ids, Long userId) {
        log.info("导出配置: ids={}, userId={}", ids, userId);

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AiConfig::getUserId, userId)
                .eq(AiConfig::getIsDeleted, false)
                .orderByDesc(AiConfig::getCreatedAt);
        
        if (ids != null && !ids.isEmpty()) {
            wrapper.in(AiConfig::getId, ids);
        }

        List<AiConfig> configs = aiConfigRepository.selectList(wrapper);

        // 清除敏感信息
        configs.forEach(config -> {
            config.setApiKey("***"); // 隐藏API密钥
            config.setTodayUsage(null);
            config.setTotalUsage(null);
        });

        try {
            ObjectMapper objectMapper = new ObjectMapper();
            return objectMapper.writeValueAsString(configs);
        } catch (JsonProcessingException e) {
            log.error("导出配置失败", e);
            throw new RuntimeException("导出配置失败: " + e.getMessage());
        }
    }

    /**
     * 根据用户ID获取配置列表
     *
     * @param userId 用户ID
     * @return 配置列表
     */
    @Override
    public List<AiConfig> getConfigsByUserId(Long userId) {
        log.info("根据用户ID获取配置列表: userId={}", userId);

        LambdaQueryWrapper<AiConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AiConfig::getUserId, userId)
                .eq(AiConfig::getIsDeleted, false)
                .orderByDesc(AiConfig::getIsDefault)
                .orderByDesc(AiConfig::getCreatedAt);

        return aiConfigRepository.selectList(wrapper);
    }

    /**
     * 删除用户所有配置
     *
     * @param userId 用户ID
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteAllUserConfigs(Long userId) {
        log.info("删除用户所有配置: userId={}", userId);

        LambdaUpdateWrapper<AiConfig> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(AiConfig::getUserId, userId)
                .set(AiConfig::getIsDeleted, true)
                .set(AiConfig::getUpdatedAt, LocalDateTime.now());

        aiConfigRepository.update(null, wrapper);
    }

    /**
     * 从文件导入AI配置
     *
     * @param file   配置文件
     * @param userId 用户ID
     * @return 导入的配置列表
     */
    public List<AiConfig> importAiConfigs(MultipartFile file, Long userId) {
        log.info("从文件导入AI配置: userId={}, fileName={}", userId, file.getOriginalFilename());

        try {
            String configData = new String(file.getBytes(), StandardCharsets.UTF_8);
            return importConfigs(configData, userId);
        } catch (IOException e) {
            log.error("读取导入文件失败", e);
            throw new RuntimeException("读取导入文件失败: " + e.getMessage());
        }
    }

    /**
     * 导出AI配置
     *
     * @param userId 用户ID
     * @param format 导出格式
     * @return 导出的配置数据
     */
    public byte[] exportAiConfigs(Long userId, String format) {
        log.info("导出AI配置: userId={}, format={}", userId, format);

        String configData = exportConfigs(null, userId);

        // 目前只支持JSON格式
        if (!"json".equalsIgnoreCase(format)) {
            log.warn("不支持的导出格式: {}, 使用默认的JSON格式", format);
        }

        return configData.getBytes(StandardCharsets.UTF_8);
    }

    // 私有辅助方法

    /**
     * 模拟连接测试
     */
    private boolean mockConnectionTest(AiConfig config) {
        // TODO: 实现真实的连接测试逻辑
        // 这里应该根据不同的提供商调用相应的API进行测试

        log.info("模拟连接测试: provider={}, model={}", config.getProvider(), config.getModel());

        // 模拟测试结果
        return StringUtils.hasText(config.getApiKey()) && StringUtils.hasText(config.getApiUrl());
    }
}